using UdonSharp;
using UnityEngine;
using UnityEngine.UI;
using VRC.SDKBase;
using VRC.Udon;

/// <summary>
/// 世界生命值系统 - 管理玩家生命值、心跳、速度设置和重生功能
/// 这是一个综合性的生命值管理系统，提供完整的生存机制
/// </summary>
public class WorldHealth : UdonSharpBehaviour
{
    // ================================ 生命值核心数据 ================================
    [Header("生命值设置")]
    [Tooltip("当前生命值 - 玩家当前的血量，范围0-100")]
    [Range(0, 100)] public int currentHealth = 100;
    
    [Tooltip("最大生命值 - 玩家可拥有的最大血量")]
    public int maxHealth = 100;
    
    // ================================ 心跳与耐力系统 ================================
    [Header("心跳与耐力设置")]
    [Tooltip("启用心跳系统 - 是否开启基于移动的动态心跳模拟")]
    public bool enableHeartRateSystem = true;
    
    [Tooltip("当前心跳 - 玩家当前的心跳频率（每分钟次数）")]
    public int currentHeartRate = 72;
    
    [Tooltip("静息心跳最小值 - 玩家静止时的最低心跳频率")]
    [Range(60, 90)] public int restingHeartRateMin = 75;
    
    [Tooltip("静息心跳最大值 - 玩家静止时的最高心跳频率")]
    [Range(75, 100)] public int restingHeartRateMax = 90;
    
    [Tooltip("步行心跳最小值 - 玩家步行时的最低心跳频率")]
    [Range(85, 120)] public int walkingHeartRateMin = 91;
    
    [Tooltip("步行心跳最大值 - 玩家步行时的最高心跳频率")]
    [Range(100, 140)] public int walkingHeartRateMax = 110;
    
    [Tooltip("最大心跳值 - 玩家可达到的最高心跳频率，超过此值将进入疲劳状态")]
    [Range(150, 200)] public int maxHeartRate = 180;
    
    [Tooltip("心跳恢复阈值 - 心跳降到此值以下时退出疲劳状态")]
    [Range(100, 150)] public int heartRateRecoveryThreshold = 120;
    
    [Tooltip("心跳下降速率 - 心跳恢复的速度倍数，数值越大恢复越快")]
    [Range(0.1f, 3f)] public float heartRateDeclineRate = 1.5f;
    
    [Tooltip("步行心跳增加速率 - 步行时心跳上升的速度")]
    [Range(0.01f, 0.5f)] public float walkHeartRateIncreaseRate = 0.12f;
    
    [Tooltip("跑步心跳增加速率 - 跑步时心跳上升的速度")]
    [Range(0.1f, 1f)] public float runHeartRateIncreaseRate = 0.35f;
    
    [Tooltip("剧烈运动阈值 - 持续移动超过此秒数将被认为是跑步")]
    [Range(5f, 30f)] public float intensiveMovementThreshold = 10f;

    // ================================ 固定速度系统 ================================
    [Header("固定速度系统")]
    [Tooltip("启用固定速度系统 - 是否强制玩家使用统一的移动速度")]
    public bool enableFixedSpeedSystem = true;
    
    [Tooltip("统一固定速度 - 玩家步行和跑步的统一速度值（米/秒）")]
    [Range(2f, 15f)] public float unifiedFixedSpeed = 6f;
    
    [Tooltip("禁用趴下 - 是否禁用玩家的趴下功能（在VRChat中无法直接禁用）")]
    public bool disableProne = true;
    
    [Tooltip("速度重新应用间隔 - 多久重新应用一次速度设置（秒）")]
    [Range(0.5f, 5f)] public float speedReapplyInterval = 1f;
    
    // ================================ 重生系统 ================================
    [Header("伤害与重生系统")]
    [Tooltip("重生点 - 玩家死亡后重生的位置和旋转")]
    public Transform respawnPoint;
    
    [Tooltip("启用重生系统 - 玩家死亡后是否自动重生")]
    public bool enableRespawnSystem = true;
    
    [Tooltip("重生延迟 - 玩家死亡后多少秒开始重生")]
    [Range(0f, 5f)] public float respawnDelay = 2f;

    [Header("屏幕边框受伤特效")]
    [Tooltip("启用受伤特效 - 是否显示屏幕边框受伤效果")]
    public bool enableDamageEffect = true;
    
    [Tooltip("受伤特效UI图像 - 用于显示红色边框效果的Image组件")]
    public Image damageEffectImage;
    
    [Tooltip("受伤特效颜色 - 受伤时显示的颜色")]
    public Color damageEffectColor = new Color(1f, 0f, 0f, 0.5f);
    
    [Tooltip("特效持续时间 - 受伤特效显示的持续时间（秒）")]
    [Range(0.5f, 3f)] public float effectDuration = 1.5f;
    
    [Tooltip("特效淡出时间 - 特效淡出消失的时间（秒）")]
    [Range(0.1f, 2f)] public float fadeOutDuration = 1f;
    
    [Tooltip("脉冲效果 - 是否启用脉冲闪烁效果")]
    public bool enablePulseEffect = true;
    
    [Tooltip("脉冲频率 - 每秒脉冲次数")]
    [Range(1f, 10f)] public float pulseFrequency = 3f;
    
    [Tooltip("最大透明度 - 特效的最大透明度")]
    [Range(0.1f, 1f)] public float maxAlpha = 0.6f;

    [Header("后处理伤害特效")]
    [Tooltip("后处理Volume组件 - 用于专业的屏幕边缘泛红效果")]
    public GameObject postProcessVolume;
    
    [Tooltip("是否启用后处理伤害特效")]
    public bool enablePostProcessDamageEffect = true;
    
    [Tooltip("后处理特效的闪烁频率（秒）")]
    [Range(0.1f, 2f)]
    public float postProcessFlashRate = 0.5f;
    
    [Tooltip("后处理特效的最大强度")]
    [Range(0.1f, 1f)]
    public float postProcessMaxIntensity = 0.6f;
    
    [Tooltip("后处理特效持续时间（秒）")]
    [Range(0.1f, 2f)]
    public float postProcessDuration = 0.8f;
    
    [Tooltip("是否使用脉冲效果而不是闪烁")]
    public bool usePostProcessPulseEffect = true;

    // ================================ 内部状态变量 ================================
    private float lastUpdateTime = 0f; // 上次更新时间
    private float lastSpeedUpdateTime = 0f; // 上次速度更新时间
    private Vector3 lastPlayerPosition; // 上次玩家位置
    private float lastHeartRateUpdateTime = 0f; // 上次心跳更新时间
    private bool isPlayerMoving = false; // 玩家是否在移动
    private bool isPlayerRunning = false; // 玩家是否在跑步
    private bool isFatigued = false; // 玩家是否疲劳
    private float movementDetectionThreshold = 0.1f; // 移动检测阈值
    private float continuousMovementTime = 0f; // 持续移动时间
    private float continuousRestTime = 0f; // 持续休息时间

    // ================================ 受伤特效状态变量 ================================
    private bool isDamageEffectActive = false; // 受伤特效是否激活
    private float damageEffectStartTime = 0f; // 特效开始时间
    private Color originalImageColor; // 原始图像颜色
    private bool isImageInitialized = false; // 图像是否已初始化
    
    // ================================ 后处理特效状态变量 ================================
    private bool isPostProcessEffectActive = false; // 后处理特效是否激活
    private float postProcessEffectStartTime = 0f; // 后处理特效开始时间

    /// <summary>
    /// 初始化生命值系统 - 在游戏开始时设置初始状态
    /// </summary>
    void Start()
    {
        InitializeHeartRateSystem(); // 初始化心跳系统
        ApplySpeedBoost(); // 应用速度设置
        InitializePostProcessDamageEffect(); // 初始化后处理伤害特效
    }
    
    /// <summary>
    /// 每帧更新 - 处理心跳系统和速度重新应用
    /// </summary>
    void Update()
    {
        // 控制更新频率，每0.05秒更新一次心跳系统以降低性能开销
        bool shouldUpdateNormally = Time.time - lastUpdateTime > 0.05f;
        if (shouldUpdateNormally)
        {
            lastUpdateTime = Time.time;
            if (enableHeartRateSystem)
            {
                UpdateHeartRateSystem(); // 更新心跳系统
            }
        }

        // 定期重新应用速度设置，确保玩家速度不被其他系统覆盖
        if (Time.time - lastSpeedUpdateTime > speedReapplyInterval)
        {
            lastSpeedUpdateTime = Time.time;
            ApplySpeedBoost(); // 重新应用速度设置
            ApplyProneSettings(); // 重新应用趴下设置
        }
        
        // 更新后处理伤害特效
        UpdatePostProcessDamageEffect();
    }

    // ================================ 生命值管理接口 ================================
    
    /// <summary>
    /// 设置玩家生命值 - 设置玩家的当前生命值，并检查是否死亡
    /// </summary>
    /// <param name="newHealth">新的生命值</param>
    public void SetHealth(int newHealth)
    {
        int oldHealth = currentHealth;
        currentHealth = Mathf.Clamp(newHealth, 0, maxHealth); // 限制生命值在0到最大值之间
        
        // 如果生命值降低，触发伤害特效
        if (oldHealth > currentHealth && currentHealth >= 0)
        {
            TriggerDamageEffects(); // 触发伤害特效
        }
        
        // 检查玩家是否从有生命变为死亡状态
        if (oldHealth > 0 && currentHealth == 0)
        {
            OnPlayerDeath(); // 触发死亡事件
        }
    }
    
    /// <summary>
    /// 减少玩家生命值 - 对玩家造成伤害
    /// </summary>
    /// <param name="amount">伤害数值</param>
    public void RemoveHealth(int amount)
    {
        SetHealth(currentHealth - amount);
    }

    /// <summary>
    /// 增加玩家生命值 - 为玩家治疗
    /// </summary>
    /// <param name="amount">治疗数值</param>
    public void AddHealth(int amount)
    {
        SetHealth(currentHealth + amount);
    }

    /// <summary>获取当前生命值</summary>
    public int GetCurrentHealth() { return currentHealth; }
    
    /// <summary>获取最大生命值</summary>
    public int GetMaxHealth() { return maxHealth; }
    
    /// <summary>检查玩家是否死亡</summary>
    public bool IsPlayerDead() { return currentHealth <= 0; }
    
    /// <summary>检查玩家是否处于危险状态（生命值低于30%）</summary>
    public bool IsPlayerInDanger() { return (float)currentHealth / maxHealth < 0.3f; }
    
    /// <summary>获取生命值百分比</summary>
    public float GetHealthPercentage() { return (float)currentHealth / maxHealth; }
    
    /// <summary>检查生命值系统是否已初始化</summary>
    public bool IsHealthSystemInitialized() { return currentHealth >= 0 && maxHealth > 0; }

    /// <summary>
    /// 立即杀死玩家 - 强制将玩家生命值设为0并触发死亡
    /// </summary>
    public void InstantlyKillPlayer()
    {
        SetHealth(0); // 生命值归零
        OnPlayerDeath(); // 立即触发死亡处理
    }
    
    /// <summary>
    /// 玩家死亡处理 - 私有方法，处理玩家死亡后的逻辑
    /// </summary>
    private void OnPlayerDeath()
    {
        if (!enableRespawnSystem) return; // 如果重生系统未启用则直接返回
        
        // 延迟指定时间后执行重生
        SendCustomEventDelayedSeconds(nameof(RespawnPlayer), respawnDelay);
    }
    
    /// <summary>
    /// 重生玩家 - 恢复玩家的生命值、心跳状态并传送到重生点
    /// </summary>
    public void RespawnPlayer()
    {
        if (Networking.LocalPlayer == null) return; // 确保本地玩家存在
        
        // 恢复满血
        currentHealth = maxHealth;
        
        // 如果启用心跳系统，重置心跳相关状态
        if (enableHeartRateSystem)
        {
            currentHeartRate = (restingHeartRateMin + restingHeartRateMax) / 2; // 重置为静息心跳
            isFatigued = false; // 清除疲劳状态
            continuousMovementTime = 0f; // 重置移动计时
            continuousRestTime = 0f; // 重置休息计时
        }
        
        // 传送玩家到重生点
        if (respawnPoint != null)
        {
            Networking.LocalPlayer.TeleportTo(respawnPoint.position, respawnPoint.rotation);
        }
        else
        {
            // 如果没有设置重生点，传送到世界原点
            Networking.LocalPlayer.TeleportTo(Vector3.zero, Quaternion.identity);
        }
    }

    // ================================ 固定速度系统方法 ================================
    
    /// <summary>
    /// 应用速度增强 - 根据设置应用固定速度或默认速度
    /// </summary>
    public void ApplySpeedBoost()
    {
        if (Networking.LocalPlayer == null) return; // 确保本地玩家存在
        
        if (enableFixedSpeedSystem)
        {
            // 应用统一固定速度（步行和跑步使用相同速度）
            Networking.LocalPlayer.SetWalkSpeed(unifiedFixedSpeed);
            Networking.LocalPlayer.SetRunSpeed(unifiedFixedSpeed);
        }
        else
        {
            // 使用VRChat默认速度
            Networking.LocalPlayer.SetWalkSpeed(2f);
            Networking.LocalPlayer.SetRunSpeed(4f);
        }
    }

    /// <summary>
    /// 重置为VRChat默认速度 - 恢复原始的步行和跑步速度
    /// </summary>
    [ContextMenu("重置为VRChat默认速度")]
    public void ResetMovementSpeed()
    {
        if (Networking.LocalPlayer == null) return;
        Networking.LocalPlayer.SetWalkSpeed(2f); // VRChat默认步行速度
        Networking.LocalPlayer.SetRunSpeed(4f); // VRChat默认跑步速度
    }

    /// <summary>
    /// 重新应用移动速度设置 - 刷新所有移动相关设置
    /// </summary>
    [ContextMenu("重新应用固定速度系统")]
    public void ReapplyMovementSpeed()
    {
        ApplySpeedBoost(); // 重新应用速度设置
        ApplyProneSettings(); // 重新应用趴下设置
    }
    
    public void ApplyProneSettings()
    {
        if (Networking.LocalPlayer == null) return;
        // 无法通过Udon直接禁用趴下，保留占位，避免UI或日志
    }

    [ContextMenu("强制应用正常状态速度")]
    public void ForceApplyNormalSpeed()
    {
        if (Networking.LocalPlayer == null || !enableFixedSpeedSystem) return;
            Networking.LocalPlayer.SetWalkSpeed(unifiedFixedSpeed);
            Networking.LocalPlayer.SetRunSpeed(unifiedFixedSpeed);
    }

    [ContextMenu("强制应用统一固定速度")]
    public void ForceApplyUnifiedSpeed()
    {
        if (Networking.LocalPlayer == null || !enableFixedSpeedSystem) return;
            Networking.LocalPlayer.SetWalkSpeed(unifiedFixedSpeed);
            Networking.LocalPlayer.SetRunSpeed(unifiedFixedSpeed);
    }

    [ContextMenu("强制应用所有移动设置")]
    public void ForceApplyAllMovementSettings()
    {
        ApplySpeedBoost();
        ApplyProneSettings();
    }
    
    [ContextMenu("显示当前速度状态")]
    public void ShowCurrentSpeedStatus() { }

    // ================================ 心跳系统方法 ================================
    
    /// <summary>
    /// 初始化心跳系统 - 设置心跳系统的初始状态
    /// </summary>
    void InitializeHeartRateSystem()
    {
        if (!enableHeartRateSystem) return; // 如果心跳系统未启用则直接返回
        
        // 设置初始心跳为静息心跳的中间值
        currentHeartRate = (restingHeartRateMin + restingHeartRateMax) / 2;
        
        // 记录玩家初始位置用于移动检测
        if (Networking.LocalPlayer != null)
        {
            lastPlayerPosition = Networking.LocalPlayer.GetPosition();
        }
        
        // 初始化状态变量
        isPlayerMoving = false;
        isPlayerRunning = false;
        isFatigued = false;
        lastHeartRateUpdateTime = Time.time;
        continuousMovementTime = 0f;
        continuousRestTime = 0f;
        
        // 确保生命值在有效范围内
        currentHealth = Mathf.Clamp(currentHealth, 0, maxHealth);
    }

    /// <summary>
    /// 更新心跳系统 - 根据玩家移动状态更新心跳频率
    /// </summary>
    void UpdateHeartRateSystem()
    {
        if (!enableHeartRateSystem || Networking.LocalPlayer == null) return;
        float deltaTime = Time.time - lastHeartRateUpdateTime;
        if (deltaTime < 9f) return; // 降低性能开销，每9秒更新一次
        lastHeartRateUpdateTime = Time.time;
        
        DetectPlayerMovement(deltaTime); // 检测玩家移动状态
        UpdateHeartRateBasedOnMovement(deltaTime); // 根据移动状态更新心跳
        CheckFatigueStatus(); // 检查疲劳状态
        currentHeartRate = Mathf.Clamp(currentHeartRate, 50, 220); // 限制心跳范围
    }
    
    /// <summary>检测玩家移动状态</summary>
    void DetectPlayerMovement(float deltaTime)
    {
        Vector3 currentPosition = Networking.LocalPlayer.GetPosition();
        Vector3 movement = currentPosition - lastPlayerPosition;
        float movementDistance = movement.magnitude;
        float movementSpeed = movementDistance / deltaTime;
        isPlayerMoving = movementSpeed > movementDetectionThreshold;
        isPlayerRunning = isPlayerMoving && continuousMovementTime > intensiveMovementThreshold;
        if (isPlayerMoving)
        {
            continuousMovementTime += deltaTime;
            continuousRestTime = 0f;
        }
        else
        {
            continuousRestTime += deltaTime;
            continuousMovementTime = 0f;
        }
        lastPlayerPosition = currentPosition;
    }
    
    /// <summary>根据移动状态更新心跳</summary>
    void UpdateHeartRateBasedOnMovement(float deltaTime)
    {
        float heartRateChange = 0f;
        
        if (isPlayerRunning)
        {
            float intensiveMultiplier = Mathf.Min((continuousMovementTime - intensiveMovementThreshold) / 15f, 1f);
            heartRateChange = runHeartRateIncreaseRate * deltaTime * (0.2f + intensiveMultiplier * 0.8f);
        }
        else if (isPlayerMoving)
        {
            float walkingMultiplier = Mathf.Min(continuousMovementTime / 20f, 1f);
            float targetHeartRate = (walkingHeartRateMin + walkingHeartRateMax) / 2f;
            if (currentHeartRate < targetHeartRate)
            {
                heartRateChange = walkHeartRateIncreaseRate * deltaTime * (0.1f + walkingMultiplier * 0.9f);
            }
            else if (currentHeartRate > walkingHeartRateMax)
            {
                heartRateChange = -heartRateDeclineRate * deltaTime * 0.2f;
            }
        }
        else
        {
            float targetHeartRate = (restingHeartRateMin + restingHeartRateMax) / 2f;
            if (currentHeartRate > targetHeartRate)
            {
                float restMultiplier = Mathf.Min(continuousRestTime / 10f, 1f);
                heartRateChange = -heartRateDeclineRate * deltaTime * (0.3f + restMultiplier * 0.7f);
            }
        }
        
        currentHeartRate = Mathf.RoundToInt(currentHeartRate + heartRateChange);
    }
    
    /// <summary>检查疲劳状态</summary>
    void CheckFatigueStatus()
    {
        if (currentHeartRate >= maxHeartRate && !isFatigued)
        {
            isFatigued = true;
        }
        else if (currentHeartRate < heartRateRecoveryThreshold && isFatigued)
        {
            isFatigued = false;
        }
    }
    
    /// <summary>重置心跳系统到初始状态</summary>
    [ContextMenu("重置心跳系统")]
    public void ResetHeartRateSystem()
    {
        InitializeHeartRateSystem();
    }
    
    /// <summary>模拟疲劳状态用于测试</summary>
    [ContextMenu("模拟疲劳状态")]
    public void SimulateFatigue()
    {
        currentHeartRate = maxHeartRate + 10;
        isFatigued = true;
    }
    
    // ================================ 兼容接口 ================================
    /// <summary>强制刷新所有UI - 兼容接口，外部系统可能调用</summary>
    public void ForceRefreshAllUI() { }
    
    // ================================ ADGZ系统联动接口 ================================
    
    /// <summary>
    /// 持续扣血 - 专门为ADGZ系统设计的扣血接口
    /// </summary>
    /// <param name="damageAmount">每次扣血数量</param>
    public void ContinuousDamage(int damageAmount)
    {
        if (currentHealth > 0)
        {
            RemoveHealth(damageAmount);
        }
    }
    
    /// <summary>
    /// 检查是否可以继续扣血（玩家是否还活着）
    /// </summary>
    public bool CanTakeDamage()
    {
        return currentHealth > 0;
    }
    
    /// <summary>
    /// 获取生命值状态信息用于调试
    /// </summary>
    public string GetHealthStatusInfo()
    {
        return $"当前血量: {currentHealth}/{maxHealth} ({GetHealthPercentage():P1})";
    }
    
    // ================================ 后处理伤害特效系统 ================================
    
    /// <summary>
    /// 初始化后处理伤害特效
    /// </summary>
    private void InitializePostProcessDamageEffect()
    {
        if (postProcessVolume != null)
        {
            // 初始化后处理Volume
            SetPostProcessVolumeWeight(0f);
            
            Debug.Log($"[WorldHealth] 后处理伤害特效已初始化");
        }
    }
    
    /// <summary>
    /// 触发所有伤害特效（UI和后处理）
    /// </summary>
    private void TriggerDamageEffects()
    {
        // 触发后处理特效
        TriggerPostProcessDamageEffect();
        
        // 这里可以继续触发其他类型的伤害特效
        // 比如UI特效等
    }
    
    /// <summary>
    /// 触发后处理伤害特效
    /// </summary>
    private void TriggerPostProcessDamageEffect()
    {
        if (!enablePostProcessDamageEffect || postProcessVolume == null)
        {
            return;
        }
        
        // 激活特效
        isPostProcessEffectActive = true;
        postProcessEffectStartTime = Time.time;
        
        Debug.Log($"[WorldHealth] 触发后处理伤害特效");
    }
    
    /// <summary>
    /// 更新后处理伤害特效
    /// </summary>
    private void UpdatePostProcessDamageEffect()
    {
        if (!enablePostProcessDamageEffect || !isPostProcessEffectActive || postProcessVolume == null)
        {
            return;
        }
        
        float elapsed = Time.time - postProcessEffectStartTime;
        
        // 检查特效是否应该结束
        if (elapsed >= postProcessDuration)
        {
            // 结束特效
            isPostProcessEffectActive = false;
            SetPostProcessVolumeWeight(0f);
            return;
        }
        
        // 计算当前强度
        float intensity;
        
        if (usePostProcessPulseEffect)
        {
            // 脉冲效果：渐入渐出
            float progress = elapsed / postProcessDuration;
            intensity = Mathf.Sin(progress * Mathf.PI) * postProcessMaxIntensity;
        }
        else
        {
            // 闪烁效果
            float flashCycle = elapsed * postProcessFlashRate;
            intensity = (Mathf.Sin(flashCycle * 2f * Mathf.PI) + 1f) * 0.5f * postProcessMaxIntensity;
        }
        
        // 应用后处理效果
        SetPostProcessVolumeWeight(intensity);
    }
    
    /// <summary>
    /// 设置Volume的权重（Udon兼容版本）
    /// </summary>
    private void SetPostProcessVolumeWeight(float weight)
    {
        if (postProcessVolume == null) return;
        
        // 在Udon中，我们需要通过SendCustomEvent来控制Volume
        // 或者使用Animator来控制权重值
        
        // 方法1：尝试通过Animator控制
        var animator = postProcessVolume.GetComponent<Animator>();
        if (animator != null)
        {
            animator.SetFloat("VolumeWeight", weight);
            Debug.Log($"[WorldHealth] 通过Animator设置Volume权重: {weight}");
            return;
        }
        
        // 方法2：尝试通过UdonBehaviour控制
        var udonBehaviour = postProcessVolume.GetComponent<UdonBehaviour>();
        if (udonBehaviour != null)
        {
            udonBehaviour.SetProgramVariable("volumeWeight", weight);
            udonBehaviour.SendCustomEvent("UpdateVolumeWeight");
            Debug.Log($"[WorldHealth] 通过UdonBehaviour设置Volume权重: {weight}");
            return;
        }
        
        // 方法3：简单的启用/禁用Volume GameObject
        // 当weight > 0时启用，weight <= 0时禁用
        bool shouldEnable = weight > 0f;
        if (postProcessVolume.activeSelf != shouldEnable)
        {
            postProcessVolume.SetActive(shouldEnable);
        }
        
        Debug.Log($"[WorldHealth] Volume GameObject已{(shouldEnable ? "启用" : "禁用")} (weight: {weight})");
    }
    
    /// <summary>
    /// 停止后处理伤害特效
    /// </summary>
    public void StopPostProcessDamageEffect()
    {
        isPostProcessEffectActive = false;
        
        if (postProcessVolume != null)
        {
            SetPostProcessVolumeWeight(0f);
        }
        
        Debug.Log($"[WorldHealth] 停止后处理伤害特效");
    }
    
    /// <summary>
    /// 手动触发后处理伤害特效（调试用）
    /// </summary>
    [ContextMenu("手动触发后处理伤害特效")]
    public void ManualTriggerPostProcessDamageEffect()
    {
        TriggerPostProcessDamageEffect();
        Debug.Log($"[WorldHealth] 手动触发后处理伤害特效");
    }
}

